home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: delta / whiteline CD Series - delta.iso / progtool / modula2 / module / easydial.mod < prev    next >
Text File  |  1995-11-25  |  19KB  |  571 lines
  1. IMPLEMENTATION MODULE EasyDialog;
  2. (* Version*: 20.12.89   00:21*)
  3.  
  4. FROM SYSTEM IMPORT ADR,SHIFT,ADDRESS,VAL,WORD,TSIZE;
  5.  
  6. FROM AES IMPORT WindowUpdate, GrafMouseKeyboardState,FileSelectorInput,
  7.                 FormCenter,FormDialogue,ObjectDraw,FormDo,ObjectChange,
  8.                 GrafMouse,WindowGet,GrafDragBox,
  9.                 ObjectFind,EventMultiple,ObjectEdit;
  10.  
  11. FROM GEMDOS IMPORT GetDrv,GetPath,ConOut;
  12. FROM XBIOS104   IMPORT KeyTable,SetKeyTable, KeyTablePtr,KeyTrans,KeyTransPtr;
  13.  
  14. FROM CookieJar IMPORT Cookie,GetCookie,CreateCookie;
  15. FROM Strings IMPORT Concat,Length,DeleteChar;
  16. FROM BitBlt IMPORT CopyMemToScreen,CopyScreenToMem;
  17. FROM GEMAESbase IMPORT Normal,MouseOff,MouseOn,
  18.                 Editable,FlatHand,Arrow,GraphicButton,Default,
  19.                 BeginUpdate,EndUpdate,Selectable,Black,White,
  20.                 KeyboardEvent,ButtonEvent,BitBlk,Crossed,Checked,
  21.                 FormStart,FormGrow,FormShrink,FormFinish,
  22.                 Object,TEdInfo,Selected,GemCall,
  23.                 IntIn2,IntIn3,
  24.                 AESGlobal,AESAddrIn,AESIntOut,AESIntIn;
  25.  
  26.  
  27. VAR SizeOfObject:INTEGER;
  28.     DX,DY,DW,DH     :INTEGER;
  29.     buf             :ADDRESS;
  30.     MouseX,MouseY   :INTEGER;
  31.     ch              :CHAR;
  32.     ButtonIndex     :INTEGER;
  33.     DefaultObject   :INTEGER;
  34.  
  35.  
  36. PROCEDURE GetObjectPointer( TreePtr:ADDRESS; Index :INTEGER  ) : ADDRESS;
  37. BEGIN
  38.     RETURN TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  39. END GetObjectPointer;
  40.  
  41. PROCEDURE GetObjectTail( TreePtr:ADDRESS; Index :INTEGER  ) : INTEGER;
  42. VAR     Probe   :POINTER TO Object;
  43. BEGIN
  44.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  45.     RETURN Probe^.tail;
  46. END GetObjectTail;
  47.  
  48. PROCEDURE GetObjectHead( TreePtr:ADDRESS; Index :INTEGER ) : INTEGER;
  49. VAR     Probe   :POINTER TO Object;
  50. BEGIN
  51.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  52.     RETURN Probe^.head;
  53. END GetObjectHead;
  54.  
  55. PROCEDURE GetObjectType( TreePtr:ADDRESS; Index :INTEGER ) : INTEGER;
  56. VAR     Probe   :POINTER TO Object;
  57. BEGIN
  58.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  59.     RETURN Probe^.type;
  60. END GetObjectType;
  61.  
  62. PROCEDURE GetObjectState( TreePtr:ADDRESS; Index :INTEGER ) : INTEGER;
  63. VAR     Probe   :POINTER TO Object;
  64. BEGIN
  65.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  66.     RETURN Probe^.state;
  67. END GetObjectState;
  68.  
  69.  
  70.  
  71. PROCEDURE GetNextObject( TreePtr:ADDRESS; Index :INTEGER ) : INTEGER;
  72. VAR     Probe   :POINTER TO Object;
  73. BEGIN
  74.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  75.     RETURN Probe^.next;
  76. END GetNextObject;
  77.  
  78. PROCEDURE GetObjectFlags(Index:INTEGER; TreePtr:ADDRESS ) : INTEGER;
  79. VAR     Probe   :POINTER TO Object;
  80. BEGIN
  81.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  82.     RETURN Probe^.flags;
  83. END GetObjectFlags;
  84.  
  85. PROCEDURE SetObjectFlags(Index:INTEGER; TreePtr:ADDRESS; NewFlag:INTEGER );
  86. VAR     Probe   :POINTER TO Object;
  87. BEGIN
  88.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  89.     Probe^.flags:=NewFlag;
  90. END SetObjectFlags;
  91.  
  92. PROCEDURE GetObjectXYWH(Index:INTEGER; TreePtr:ADDRESS;VAR x,y,w,h:CARDINAL);
  93. VAR     Probe   :POINTER TO Object;
  94. BEGIN
  95.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  96.     x:= Probe^.x;
  97.     y:= Probe^.y;
  98.     w:= Probe^.width;
  99.     h:= Probe^.height;
  100. END GetObjectXYWH;
  101.  
  102. PROCEDURE SetObjectXYWH(Index:INTEGER; TreePtr:ADDRESS;x,y,w,h:CARDINAL );
  103. VAR     Probe   :POINTER TO Object;
  104. BEGIN
  105.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  106.     Probe^.x:=x;
  107.     Probe^.y:=y;
  108.     Probe^.width:=w;
  109.     Probe^.height:=h;
  110. END SetObjectXYWH;
  111.  
  112.  
  113.  
  114. PROCEDURE GetText(Index:INTEGER;TreePtr:ADDRESS; VAR String: ARRAY OF CHAR );
  115. VAR    StringAdr :POINTER TO TEdInfo;
  116.            Probe :POINTER TO Object;
  117.              Str :POINTER TO ARRAY[0..63] OF CHAR;
  118.              i:INTEGER;
  119.  
  120. BEGIN
  121.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  122.     StringAdr:=(Probe^.spec);
  123.     Str:=StringAdr^.ptext;
  124.     FOR i:=0 TO HIGH(String) DO
  125.         String[i]:= Str^[i];
  126.     END(*FOR*);
  127. END GetText;
  128.  
  129. PROCEDURE SetText(Index:INTEGER;TreePtr:ADDRESS; String: ARRAY OF CHAR );
  130. VAR    StringAdr :POINTER TO TEdInfo;
  131.            Probe :POINTER TO Object;
  132.              Str :POINTER TO ARRAY[0..63] OF CHAR;
  133.              i:INTEGER;
  134.  
  135. BEGIN
  136.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  137.     StringAdr:=(Probe^.spec);
  138.     Str:=StringAdr^.ptext;
  139.     FOR i:=0 TO HIGH(String) DO
  140.         Str^[i]:=String[i];
  141.     END(*FOR*);
  142. END SetText;
  143.  
  144. PROCEDURE GetBoxColor(Index:INTEGER;TreePtr:ADDRESS):INTEGER;
  145. TYPE
  146.       adr2bs = RECORD CASE : BOOLEAN OF
  147.                         TRUE : a : ADDRESS;
  148.                         |FALSE: h,l : BITSET;
  149.                       END(*CASE*);
  150.                END(*RECORD*);
  151.  
  152. VAR        bs : adr2bs;
  153.            Probe :POINTER TO Object;
  154.                 i:INTEGER;
  155.  
  156. BEGIN
  157.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  158.     (* Im letzten Nibble ist die Farbe kodiert von 0-F);*)
  159.     bs.a:=Probe^.spec;
  160.     i:=VAL(INTEGER,(bs.l * {0..3}));
  161.     RETURN i
  162. END GetBoxColor;
  163.  
  164. PROCEDURE SetBoxColor(Index:INTEGER;TreePtr:ADDRESS;Colour :INTEGER);
  165. TYPE
  166.       adr2bs = RECORD CASE : BOOLEAN OF
  167.                         TRUE : a : ADDRESS;
  168.                         |FALSE: h,l : BITSET;
  169.                       END(*CASE*);
  170.                END(*RECORD*);
  171.  
  172. VAR        bs : adr2bs;
  173.            Probe :POINTER TO Object;
  174.  
  175. BEGIN
  176.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  177.     bs.a:=Probe^.spec;
  178.     bs.l:=bs.l * {4..15};
  179.     bs.l:=bs.l + VAL(BITSET,Colour);
  180.     Probe^.spec:=bs.a
  181. END SetBoxColor;
  182.  
  183.  
  184.  
  185. PROCEDURE WorkTree(TreePtr :ADDRESS; StartObject,EndObject :INTEGER;
  186.                     Do: TreePROC);
  187. VAR
  188.    ObjectIndex,
  189.    Head, Tail   :INTEGER;
  190. BEGIN
  191.    ObjectIndex:=StartObject;
  192.    REPEAT
  193.       Do(TreePtr,ObjectIndex);
  194.       Head:= GetObjectHead(TreePtr,ObjectIndex);
  195.       Tail:= GetObjectTail(TreePtr,ObjectIndex);
  196.       IF Head # -1 THEN
  197.          WorkTree(TreePtr,Head,Tail,Do);
  198.       END(*IF*);
  199.       IF ObjectIndex # EndObject THEN
  200.          ObjectIndex:=GetNextObject(TreePtr,ObjectIndex);
  201.       ELSE
  202.          ObjectIndex:=-1;
  203.       END(*IF*);
  204.    UNTIL ObjectIndex=(-1)
  205. END WorkTree;
  206.  
  207. PROCEDURE FormButton(Tree :ADDRESS; Object,Clicks : INTEGER;
  208.                      VAR NextObject :INTEGER):INTEGER;
  209. VAR ExButton : INTEGER;
  210. BEGIN
  211.    AESAddrIn[0]:=Tree;
  212.    IntIn2(Object,Clicks);
  213.    ExButton:=GemCall(56,2,2,1,0);
  214.    NextObject:=AESIntOut[1];
  215.    RETURN AESIntOut[0]
  216. END FormButton;
  217.  
  218. PROCEDURE FormKeyboard(Tree :ADDRESS; Object,Next,Char:INTEGER;
  219.                        VAR NextObject,NextChar :INTEGER):INTEGER;
  220. VAR ExButton : INTEGER;
  221. BEGIN
  222.    AESAddrIn[0]:=Tree;
  223.    IntIn3(Object,Char,Next);
  224.    ExButton:=GemCall(55,3,3,1,0);
  225.    NextObject:=AESIntOut[1];
  226.    NextChar:=AESIntOut[2];
  227.    RETURN AESIntOut[0]
  228. END FormKeyboard;
  229.  
  230. PROCEDURE and(a,b:WORD):BOOLEAN;
  231. VAR c: BITSET;
  232. BEGIN
  233.   c:=VAL(BITSET,a)*VAL(BITSET,b);
  234.   IF c<>VAL(BITSET,0) THEN RETURN TRUE
  235.                       ELSE RETURN FALSE;
  236.   END(*IF*);
  237. END and;
  238.  
  239. PROCEDURE SelectCheckBox(TreePtr :ADDRESS; Index : INTEGER);
  240. VAR     Probe   :POINTER TO Object;
  241. BEGIN
  242.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  243.     IF (GetBoxColor(Index,TreePtr)=Black) AND (Probe^.state=Crossed) THEN
  244.           Probe^.state:=Probe^.state+Selected;
  245.     ELSIF  (GetBoxColor(Index,TreePtr)=Black) AND (Probe^.state=Checked) THEN
  246.           Probe^.state:=Probe^.state+Selected;
  247.     END(*IF*);
  248. END SelectCheckBox;
  249.  
  250. PROCEDURE InitCheckBoxes(TreePtr : ADDRESS);
  251. VAR SelectBoxes : TreePROC;
  252. BEGIN
  253.    SelectBoxes:=SelectCheckBox;
  254.    WorkTree(TreePtr,0,0,SelectBoxes);
  255. END  InitCheckBoxes;
  256.  
  257. PROCEDURE FindLastButtonCapChar(TreePtr :ADDRESS; Index :INTEGER);
  258. VAR     Probe   : POINTER TO Object;
  259.         s       : POINTER TO ARRAY [0..40] OF CHAR;
  260.         j       : INTEGER;
  261. BEGIN
  262.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  263.     IF (Probe^.type = GraphicButton)
  264.         AND and(Probe^.flags,Selectable) THEN
  265.         s:=Probe^.spec;
  266.         j:=-1;
  267.         REPEAT
  268.            j:= j+1
  269.         UNTIL (s^[j]=0C) OR (s^[j]=ch);
  270.         IF s^[j]#0C THEN
  271.             ButtonIndex:=Index;
  272.         END(*IF*);
  273.     END(*IF*);
  274. END FindLastButtonCapChar;
  275.  
  276. PROCEDURE FindDefault(TreePtr:ADDRESS; Index:INTEGER);
  277. VAR DiaObject : POINTER TO Object;
  278. BEGIN
  279.     DiaObject:=TreePtr+ VAL(ADDRESS,(Index*SizeOfObject));
  280.     IF and(DiaObject^.flags,Default) THEN
  281.        DefaultObject:=Index;
  282.     END(*IF*);
  283. END FindDefault;
  284.  
  285. PROCEDURE MoveDial(ID:INTEGER;TreePtr:ADDRESS);
  286. VAR x,y,w,h :CARDINAL;
  287.     deskx,desky,deskw,deskh,
  288.     xF,yF,formret :INTEGER;
  289.     String   : ARRAY [0..127] OF  CHAR;
  290. BEGIN
  291.      GetObjectXYWH(ID,TreePtr,x,y,w,h);
  292.      GrafMouse(FlatHand,NIL);
  293.      WindowGet(0,4,deskx,desky,deskw,deskh);
  294.      (* Dialogbox darf nicht ausserhalb des Bildschirms sein!!*)
  295.      GrafDragBox (w,h,x,y,deskx+3,desky+3, deskw-6, deskh-6,xF,yF);
  296.      SetObjectXYWH(ID,TreePtr,xF,yF,w,h);
  297.      GrafMouse(Arrow,NIL);
  298. END  MoveDial;
  299.  
  300.  
  301.  
  302.  
  303. PROCEDURE MoveFormDo(TreePtr :ADDRESS; EditObject :INTEGER):INTEGER;
  304.  
  305. CONST
  306.     ROOT =0;
  307.     MAXDEPTH=8;
  308.     EDINIT=1;
  309.     EDCHAR=2;
  310.     EDEND=3;
  311.  
  312. VAR pKeyTable :KeyTablePtr;
  313.     pKeyTa, KbdShift: KeyTransPtr;
  314.  
  315. VAR x,y,w,h :CARDINAL;
  316.     i,j,obj,mx,my,pos,button,cli,leave,event :INTEGER;
  317.     msg : ARRAY [0..7] OF INTEGER;
  318.     SpKey,key,NewPos : INTEGER;
  319.     specstr,buffer : ADDRESS;
  320.     SeekButton     : TreePROC;
  321.     IsDefault : TreePROC;
  322.  
  323. BEGIN
  324.    DefaultObject:=-1;
  325.    IsDefault:=FindDefault;
  326.    WorkTree(TreePtr,0,0,IsDefault);
  327.    pKeyTa:=VAL(ADDRESS,-1);
  328.    pKeyTable:=SetKeyTable( pKeyTa, pKeyTa, pKeyTa);
  329.    KbdShift:=pKeyTable^.shift;
  330.    SeekButton:= FindLastButtonCapChar;
  331.    leave :=1;
  332.    GetObjectXYWH(ROOT,TreePtr,x,y,w,h);
  333.    GrafMouse(MouseOff,NIL);
  334.    CopyScreenToMem(x-2,y-2,w+5,h+5,buffer);
  335.    ObjectDraw(TreePtr,0,6,x-2,y-2,w+4,h+4);
  336.    GrafMouse(MouseOn,NIL);
  337.    IF EditObject>0 THEN
  338.       ObjectEdit(TreePtr,EditObject,0,pos,EDINIT,NewPos);
  339.       (* Cursor einschalten *)
  340.    END(*IF*);
  341.    WHILE leave>0 DO
  342.        event := EventMultiple(KeyboardEvent+ButtonEvent,2,1,1,
  343.                               0,0,0,0,0,0,0,0,0,0,
  344.                               ADR(msg),0,0,
  345.                               mx,my,button,SpKey,key,cli);
  346.        pos := NewPos;
  347.        IF and(event,ButtonEvent) THEN
  348.           obj:=ObjectFind(TreePtr,ROOT,MAXDEPTH,mx,my);
  349.           IF obj >0 THEN
  350.              (* Ist es eine Checkbox ? *)
  351.              IF (GetObjectFlags(obj,TreePtr)=Selectable) AND
  352.                 (GetObjectState(TreePtr,obj)=Checked+Selected) AND
  353.                 (GetBoxColor(obj,TreePtr)=Black) THEN
  354.                       ObjectChange(TreePtr,obj,0,x,y,w,h,Crossed+Selected,1);
  355.              ELSIF (GetObjectFlags(obj,TreePtr)=Selectable) AND
  356.                    (GetObjectState(TreePtr,obj)=Crossed+Selected) AND
  357.                    (GetBoxColor(obj,TreePtr)=Black) THEN
  358.                        ObjectChange(TreePtr,obj,0,x,y,w,h, Checked+Selected,1);
  359.              (* Bei Editierbaren Feldern Cursor wechseln *)
  360.              ELSIF   and(GetObjectFlags(obj,TreePtr),Editable) AND (obj#EditObject) THEN
  361.                 ObjectEdit(TreePtr,EditObject,SpKey,pos,EDEND,NewPos);
  362.                 EditObject:=obj;
  363.                 ObjectEdit(TreePtr,EditObject,SpKey,pos,EDINIT,NewPos);
  364.              ELSE
  365.                leave := FormButton(TreePtr,obj,cli,obj);
  366.              END(*IF*);
  367.           ELSIF obj=0 THEN
  368.              (* Move *)
  369.               IF (EditObject>0) THEN
  370.              (* Cursor  ausschalten falls es Edit-Felder gab *)
  371.                  ObjectEdit(TreePtr,EditObject,SpKey,pos,EDEND,NewPos);
  372.               END(*IF*);
  373.               MoveDial(ROOT,TreePtr);
  374.              (* Bildschirm restaurieren *)
  375.               GrafMouse(MouseOff,NIL);
  376.               (* Bildschirm restaurieren an alter Dialogposition*)
  377.               CopyMemToScreen(x-2,y-2,w+5,h+5,buffer,TRUE);
  378.               (* Neue Dialogkoordinaten holen *)
  379.               GetObjectXYWH(ROOT,TreePtr,x,y,w,h);
  380.               (* Bildschirmhintergrund an neuer Dialogposition retten *)
  381.               CopyScreenToMem(x-2,y-2,w+5,h+5,buffer);
  382.               (* Dialog neuzeichnen *)
  383.               ObjectDraw(TreePtr,0,8,x-2,y-2,w+4,h+4);
  384.               IF (EditObject>0) THEN
  385.              (* Cursor wieder einschalten falls es Edit-Felder gab *)
  386.                  ObjectEdit(TreePtr,EditObject,SpKey,pos,EDINIT,NewPos);
  387.               END(*IF*);
  388.               GrafMouse(MouseOn,NIL);
  389.           ELSE
  390.              (*Glocke*)
  391.              ConOut(7C);
  392.           END(*IF*);
  393.         ELSIF and(event,KeyboardEvent) THEN
  394.             IF SpKey=08H THEN (* Alternate wurde gedrückt *)
  395.                 ch:=CHR(VAL(INTEGER,KbdShift^[SHIFT(key,-8)]));
  396.                 ButtonIndex:=-1;
  397.                 WorkTree(TreePtr,0,0,SeekButton);
  398.                 IF ButtonIndex #-1 THEN
  399.                    (* Eintrag gefunden !! *)
  400.                     leave := FormButton(TreePtr,ButtonIndex,1,obj);
  401.                 END(*IF*);
  402.             ELSE
  403.               (* Return gedrückt und kein DEFAULT-Object? *)
  404.               IF (DefaultObject=-1) AND ((key =7181(*RETURN*))
  405.                   OR (key=29197(*ENTER*))) THEN
  406.                   (* In TAB-Taste umsetzen *)
  407.                   key := 3849;(* TAB *)
  408.               END(*IF*);
  409.               leave:=FormKeyboard(TreePtr,EditObject,0,key,obj,SpKey);
  410.               IF SpKey >0 THEN
  411.                  ObjectEdit(TreePtr,EditObject,SpKey,pos,EDCHAR,NewPos);
  412.                ELSE
  413.                  IF and(GetObjectFlags(obj,TreePtr),Editable) AND (obj#EditObject)
  414.                  AND (obj<=GetObjectTail(TreePtr,ROOT)) THEN
  415.                    ObjectEdit(TreePtr,EditObject,SpKey,pos,EDEND,NewPos);
  416.                    EditObject:=obj;
  417.                    ObjectEdit(TreePtr,EditObject,SpKey,pos,EDINIT,NewPos);
  418.                  END(*IF*);
  419.                END(*IF*);
  420.              END(*IF*);
  421.         END(*IF*);
  422.    END(*WHILE*);
  423.    IF (EditObject>0) THEN
  424.       (* Cursor wieder ausschalten falls es Edit-Felder gab *)
  425.       ObjectEdit(TreePtr,EditObject,SpKey,pos,EDEND,NewPos);
  426.    END(*IF*);
  427.    GrafMouse(MouseOff,NIL);
  428.    (* Bildschirmhintergrund wiederherstellen *)
  429.    CopyMemToScreen(x-2,y-2,w+5,h+5,buffer,TRUE);
  430.    GrafMouse(MouseOn,NIL);
  431.    RETURN obj
  432. END MoveFormDo;
  433.  
  434.  
  435. PROCEDURE FileSelectXtendedInput(VAR InPath,InSelect:ARRAY OF CHAR;
  436.                                  VAR ExButton:INTEGER; label: ARRAY OF CHAR):INTEGER;
  437.  
  438. BEGIN
  439.    AESAddrIn[0]:=ADR(InPath);
  440.    AESAddrIn[1]:=ADR(InSelect);
  441.    AESAddrIn[2]:=ADR(label);
  442.    ExButton:=GemCall(91,3,2,3,1);
  443.    ExButton:=AESIntOut[1];
  444.    RETURN AESIntIn[1]
  445. END  FileSelectXtendedInput;
  446.  
  447. PROCEDURE EasyFileSelect(VAR Maske, DateiName:ARRAY OF CHAR;  Text : ARRAY OF CHAR):BOOLEAN;
  448. VAR
  449.     OK    : BOOLEAN;
  450.     ret   : INTEGER;
  451.     ExButton : INTEGER;
  452.     Drive,i  : CARDINAL;
  453.     DrvName  : ARRAY[0..2] OF CHAR;
  454.     PathName : ARRAY[0..127] OF CHAR;
  455.     fsel : Cookie;
  456. BEGIN
  457.      CreateCookie(fsel,'FSEL',0D);
  458.      GetDrv(Drive);
  459.      DrvName[0]:=CHR(65+Drive);DrvName[1]:=':';
  460.      DrvName[2]:=0C;
  461.      GetPath(PathName,0);
  462.      Concat(DrvName,PathName,PathName,OK);
  463.      DrvName:='\';
  464.      Concat(PathName,DrvName,PathName,OK);
  465.      Concat(PathName,Maske,Maske,OK);
  466.      IF (AESGlobal.apVersion >= 140H) OR (GetCookie(fsel))  THEN
  467.         (* FselXInput *)
  468.          ret:=FileSelectXtendedInput(Maske,DateiName,ExButton,Text);
  469.  
  470.      ELSE
  471.          (* Normale FselInput *)
  472.          FileSelectorInput(ADR(Maske),ADR(DateiName),ExButton);
  473.  
  474.      END(*IF*);
  475.      REPEAT
  476.          i:=Length(Maske);
  477.          DeleteChar(Maske,i);
  478.      UNTIL Maske[i-2]='\';
  479.      RETURN ExButton=1;
  480. END EasyFileSelect;
  481.  
  482.  
  483. PROCEDURE IsSelected(Index:INTEGER; TreePtr:ADDRESS ) : BOOLEAN;
  484. VAR     Probe   :POINTER TO Object;
  485.  
  486. BEGIN
  487.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  488.     RETURN and(Probe^.state,Selected);
  489. END IsSelected;
  490.  
  491. PROCEDURE IsCrossed(Index:INTEGER; TreePtr:ADDRESS ) : BOOLEAN;
  492. VAR     Probe   :POINTER TO Object;
  493.  
  494. BEGIN
  495.     Probe:=TreePtr+VAL(ADDRESS, (Index*SizeOfObject));
  496.     RETURN and(Probe^.state,Crossed);
  497. END IsCrossed;
  498.  
  499.  
  500. PROCEDURE DrawDialog(DialogAdresse:ADDRESS);
  501. VAR KeyState,MouseState:INTEGER;
  502.  
  503. BEGIN
  504.    WindowUpdate(BeginUpdate);
  505.    WindowUpdate(BeginMouseControl);
  506.    FormCenter(DialogAdresse,DX,DY,DW,DH);
  507.    GrafMouseKeyboardState(MouseX,MouseY,KeyState,MouseState);
  508.    GrafMouse(MouseOff,NIL);
  509.    CopyScreenToMem(DX,DY,DW,DH,buf);
  510.    IF buf=NIL THEN
  511.       FormDialogue(FormStart,MouseX,MouseY,10,10,DX,DY,DW,DH);
  512.    END(*IF*);
  513.    FormDialogue(FormGrow,MouseX,MouseY,10,10,DX,DY,DW,DH);
  514.    ObjectDraw(DialogAdresse,0,6,DX,DY,DW,DH);
  515.    GrafMouse(MouseOn,NIL);
  516. END  DrawDialog;
  517.  
  518. PROCEDURE UndrawDialog(DialogAdresse : ADDRESS);
  519. BEGIN
  520.    FormDialogue(FormShrink,MouseX,MouseY,10,10,DX,DY,DW,DH);
  521.    GrafMouse(MouseOff,NIL);
  522.    IF buf=NIL THEN
  523.       FormDialogue(FormFinish,MouseX,MouseY,10,10,DX,DY,DW,DH);
  524.    ELSE
  525.       CopyMemToScreen(DX,DY,DW,DH,buf,TRUE);
  526.    END(*IF*);
  527.    GrafMouse(MouseOn,NIL);
  528.    WindowUpdate(EndMouseControl);
  529.    WindowUpdate(EndUpdate);
  530. END  UndrawDialog;
  531.  
  532.  
  533. PROCEDURE DoDialog(DialogAdresse:ADDRESS;ErstesObject:INTEGER):INTEGER;
  534. VAR     Probe   :POINTER TO Object;
  535. DiaRETURN       :INTEGER;
  536.  
  537. BEGIN
  538.    DrawDialog(DialogAdresse);
  539.    DiaRETURN:= FormDo(DialogAdresse,ErstesObject);
  540.    Probe:=DialogAdresse+VAL(ADDRESS, (DiaRETURN *SizeOfObject));
  541.    IF and(Probe^.state,Selected) THEN
  542.      ObjectChange(DialogAdresse,DiaRETURN,0,DX,DY,DW,DH,Probe^.state-Selected,0);
  543.    END(*IF*);
  544.    UndrawDialog(DialogAdresse );
  545.    RETURN DiaRETURN;
  546. END DoDialog;
  547.  
  548. PROCEDURE DoMoveDialog(DialogAdresse:ADDRESS;ErstesObject:INTEGER):INTEGER;
  549. VAR     Probe   :POINTER TO Object;
  550. DiaRETURN       :INTEGER;
  551.  
  552. BEGIN
  553.    WindowUpdate(BeginUpdate);
  554.    WindowUpdate(BeginMouseControl);
  555.    FormCenter(DialogAdresse,DX,DY,DW,DH);
  556.    InitCheckBoxes(DialogAdresse);
  557.    DiaRETURN:= MoveFormDo(DialogAdresse,ErstesObject);
  558.    Probe:=DialogAdresse+VAL(ADDRESS, (DiaRETURN *SizeOfObject));
  559.    IF and(Probe^.state,Selected) THEN
  560.      ObjectChange(DialogAdresse,DiaRETURN,0,DX,DY,DW,DH,Probe^.state-Selected,0);
  561.    END(*IF*);
  562.    WindowUpdate(EndMouseControl);
  563.    WindowUpdate(EndUpdate);
  564.    RETURN DiaRETURN;
  565. END DoMoveDialog;
  566.  
  567.  
  568. BEGIN
  569.    SizeOfObject:=TSIZE(Object);
  570. END EasyDialog.
  571.